function Map() {
    /**
    * Inner, underlaying Map data.
    *
    * @private
    * @property _data
    * @type     Array
    */
    this._data = new Array();
}



    /**
     * Associates the specified value with the specified key in this map.
     *
     * @public
     * @method put
     * @param {String} key      map key
     * @param {Object} value    value object associated with key
     */
    Map.prototype.put = function(key, value) {

            this._data[ key ] = value;
    };

    /**
     * Copies all of the mappings from the specified Map to this Hashtable. These mappings will replace
     * any mappings that this Hashtable had for any of the keys currently in the specified Map.
     *
     * @public
     * @method putAll
     * @param  {Map} map  map of elements to insert into this map
     */
    Map.prototype.putAll = function(map) {

        var keys = map.keys();
        var it = keys.iterator();
        while (it.hasNext()) {

            var key = it.next();
            var value = map.get( key );
            // write key - value pair to 'this' map
            this._data[ key ] = value;
        }
    };

    /**
     * Get value associated with the key.
     *
     * @public
     * @method get
     * @param  {String} key    key identifying associated value object
     * @return {Object} value associated with the key
     */
    Map.prototype.get = function(key) {

            return this._data[ key ];
    };

    /**
    * Returns true if this map contains a mapping for the specified key.
    *
    * @public
    * @method constainsKey
    * @param  {String} key  key
    * @return {Boolean} true / false
    */
    Map.prototype.constainsKey = function(key) {

            try {
                var o = this._data[ key ];
                return o !== null;
            }
            catch (e) {
                return false;
            }
    };

    /**
    * Returns true if this map maps one or more keys to the specified value.
    *
    * @public
    * @method containsValue
    * @param  {Object} object object to look for
    * @return {Boolean} true / false
    */
    Map.prototype.containsValue = function( object ) {

            for (key in this._data) {
                if (this._data[ key ] == object) {
                    return true;
                }
            }
            //
            return false;
    };

    /**
     * Removes the mapping for this key from this map if it is present.
     *
     * @public
     * @method remove
     * @param  {String} key key identyfying object beeing removed
     */
    Map.prototype.remove = function( key ) {

            this._data[ key ] = null;
    };

    /**
     * Returns a collection view of the values contained in this map.
     *
     * @public
     * @method values
     * @return {List} list representing collection of values stred in the map
     */
    Map.prototype.values = function() {

            // prepare values container
            var values = new List();

            // rewrite 'non null' values
            for (key in this._data) {
                var value = this._data[ key ];

                if (value !== null) {
                    values.add(value);
                }
            }
            //
            return values;
    };

    /**
     * Returns a collection of key values.
     *
     * @public
     * @method keys
     * @return {List} collection of keys in the map
     */
    Map.prototype.keys = function() {

            // prepare keys container
            var keys = new List();

            // rewrite 'non null' keys to container
            for (var key in this._data) {

                if ( this._data[ key ] != null) {
                    keys.add(key);
                }
            }
            //
            return keys;
    };

    /**
    * Removes all mappings from this map.
    *
    * @public
    * @method clear
    */
    Map.prototype.clear = function() {

            // clear keys
            this._data = null;
            this._data = new Array();
    };

    /**
     * Tests if this hashtable maps no keys to values.
     *
     * @public
     * @method isEmpty
     * @return {Boolean} true / false
     */
    Map.prototype.isEmpty = function() {

        var keys = this.keys();
        return keys.size() == 0;
    }





